import java.util.Locale;

class Student{

}

public class Test2 {
    //字符串查找：
    public static void main1(String[] args) {
        //char charAt(int index)
        //返回index位置上字符，如果index为负数或者越界，抛出
        //StringIndexOutOfBoundsException异常

        //获取指定位置的字符
        String str1 = "abcdef";
        char ch1 = str1.charAt(2);
        System.out.println(ch1);//在字符串中根据索引下标来打印的字符串中的字符

        /*char ch2 = str1.charAt(21);//输入的值超过了字符串的长度
        System.out.println(ch2);//这个时候发生了string的字符串下标索引的越界的异常*/
    }

    public static void main2(String[] args) {
        //int indexOf(int ch)
        //返回ch第一次出现的位置，没有返回-1,返回的是int类型
        String str1 = "abccdef";
        int index1 = str1.indexOf('c');//返回了第一次的位置的下标
        System.out.println(index1);//这个是返回了字符第一次出现的位置

        System.out.println("===========");

        //int indexOf(String str)
        //返回str第一次出现的位置，没有返回-1
        int index2 = str1.indexOf("de");
        System.out.println(index2);//返回了子字符串的首字符的下标的位置

        System.out.println("===========");

        //int indexOf(int ch, int fromIndex)
        //从fromIndex位置开始找ch第一次出现的位置，没有返回-1
        //从此时输入的位置开始向后寻找
        int index3 = str1.indexOf('d',4);
        System.out.println(index3);

        System.out.println("===========");

        //int indexOf(int str, int fromIndex)
        //从fromIndex位置开始找str第一次出现的位置，没有返回-1
        //从此时输入的位置开始向后寻找
        int index4 = str1.indexOf("cc",1);
        System.out.println(index4);

        System.out.println("===================");

        //所有的indexOf的对应的LastIndexOf方法
        String str2 = "ababcdabcdef";
        int lastIndex1 = str2.lastIndexOf('a');
        System.out.println(lastIndex1);//从后往前找，但是还是返回的是正常从前到后的下标值

        int lastIndex2 = str2.lastIndexOf('a',4);
        //从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1
        System.out.println(lastIndex2);

        //int lastIndexOf(String str, int fromIndex)
        //从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1
        int lastIndex3 = str2.lastIndexOf("bc",4);
        System.out.println(lastIndex3);

        int lastIndexOf4 = str2.lastIndexOf("bc");
        //int lastIndexOf(String str)
        //从后往前找，返回str第一次出现的位置，没有返回-1
        System.out.println(lastIndexOf4);
    }


    //1. 数值和字符串转化
    public static void main3(String[] args) {
        //valueOf方法把基本数据类型转化为String类
        String s1 = String.valueOf(1234);
        String s2 = String.valueOf(12.34);
        String s3 = String.valueOf(true);
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        //底层使用了基本数据类型的类的valueOf方法

        String s4 = String.valueOf(new Student());
        System.out.println(s4);//打印的是类的哈希值和地址及路径


        /*
        这个是valueOf的返回类的方法的源码：
        public static String valueOf(Object obj) {
            return (obj == null) ? "null" : obj.toString();
        }
        上述源码也是调用了toString方法，从而打印了地址和哈希值
        */

        //字符串类型转化为数字类型
        int data1 = Integer.parseInt("1234");
        double data2 = Double.parseDouble("12.34");
        System.out.println(data1);
        System.out.println(data2);
    }

    //2.大小写转换：
    public static void main4(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO";
        String str1 = s1.toUpperCase();
        String str2 = s2.toLowerCase();
        System.out.println(str1);
        System.out.println(str2);
        //toUpperCase 和 toLowerCase的方法的返回值是String类型
        /*System.out.println(s1.toUpperCase());
        System.out.println(s2.toLowerCase());*/

        /**
         * 注意：
         * 在Java中，String类型是不可以改变的，
         * hello --> HELLO
         * 这个转换不是在原来的字符串的上面进行转换 它是生成了一个新的对象，在堆上有一个新的空间就去进行创建，所以存入了新的对象
         */

    }

    //3.字符串转数组
    public static void main5(String[] args) {
        //字符串转化为数组
        String str = "hello";
        char[] c = str.toCharArray();
        for (int i = 0; i < c.length; i++) {
            System.out.print(c[i] + " ");
        }
        System.out.println();

        /*
        toCharArray方法的源码：
        public char[] toCharArray() {
        // Cannot use Arrays.copyOf because of class initialization order issues
        char result[] = new char[value.length];
        System.arraycopy(value, 0, result, 0, value.length);
        return result;
        }
        返回的是字符数组需要用char[]来接收
        */

        System.out.println("===========");

        //字符数组转化为字符串
        char[] Array = {'h','e','l','l','o'};
        String str1 = new String(Array);
        System.out.println(str1);
    }

    //6.格式化
    public static void main6(String[] args) {
        String s = String.format("%d-%d-%d", 2006, 04, 02);
        System.out.println(s);
        //如同C语言的格式化输出！
    }


    //7.字符串的替换
    public static void main7(String[] args) {
        String str = "ababcabcdabcde";
        String ret = str.replace("ab","why");//替换字符串

        /*//当然是可以直接打印str.replace()的方法，
        System.out.println(str.replace("ab","why"));*/

        System.out.println(ret);
        //上述操作是把所有的”ab“替换为”why" 这个替换也还是一样不是在原来的字符串基础上去进行替换， 他也是产生了新的对象

        System.out.println("============");

        String ret2 = str.replace('b','z');//替换字符
        System.out.println(ret2);

        System.out.println("============");

        String ret3 =  str.replaceFirst("ab","jy");
        System.out.println(ret3);

        //repalceFirst()方法：替换的是第一次出现的目标的字符串，只能是字符串，并且是第一次出现的(替换首个内容)

        System.out.println("============");

        String ret4 = str.replaceAll("ab","jy");
        //repalceAll()方法：替换的是所有出现的目标的字符串，只能是字符串，是所有出现的(替换所有的指定内容)
        System.out.println(ret4);
        //注意事项: 由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串.

    }

    //8.字符串的拆分
    public static void main(String[] args) {
        //split要用数组来接收，按指定内容来分割
        //分割之后的结果要存储到数组当中
        String str = "name=zhangsan&age=10";
        String[] strings = str.split("&");
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }
        System.out.println("===============");
        String str2 = "Hello world hello bit";
        String[] strings1 = str2.split(" ");
        for (String a: strings1) {
            System.out.println(a);
        }//根据空格分组，打印结果我们看到了分了四组，
        //如果我们要分特定的几组，那么就需要加入特定的参数
        System.out.println("===============");
        String str3 = "Hello world hello bit";
        String[] strings2 = str3.split(" ",2);
        for (int i = 0; i < strings2.length; i++) {
            System.out.println(strings2[i]);//这个时候我们传进去了参数2，那么就是分成了两组
            /*
            Hello
            hello world hello bit
            */
        }

        //String[] split(String regex, int limit) 将字符串以指定的格式，拆分为limit组
        //String[] split(String regex) 将字符串全部拆分

        System.out.println("=================");

        String str4 = "192.168.0.0.1";
       /* String[] strings3 = str4.split(".");
       //这个时候我们用.来进行分割，但是我们发现并没有进行分割*/
        String[] strings3 = str4.split("\\.");
        //在这里处理用一定符号进行分割的情况需要加入转义字符\\
        //1. 字符"|","*","+"都得加上转义字符，前面加上 "\\" .
        //2. 而如果是 "\" ，那么就得写成 "\\\\" .
        //3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.
        for (int i = 0; i < strings3.length; i++) {
            System.out.println(strings3[i]);
        }

        System.out.println("=================");

        String str5 = "192\\168\\0\\0\\1";//在这种情况下，我们要用\\来进行分割，但是两个\表示一个\,
        //所以我们要用四个\来进行表示来指定的内容来分割
        String[] strings4 = str5.split("\\\\");
        for (int i = 0; i < strings4.length; i++) {
            System.out.println(strings4[i]);
        }

        System.out.println("==================");

        String str6 = "name=zhangsan&age=10";
        String[] strings5 = str6.split("&|=");
        for (int i = 0; i < strings5.length; i++) {
            System.out.println(strings5[i]);
        }
        //这个时候用&和=来进行分割，我们用|来进行连字符的连续的分割

        System.out.println("==================");
        String str7 = "name=zhangsan&age=10";
        String[] strings6 = str7.split("&");
        for (int i = 0; i < strings6.length; i++) {
            /*System.out.println(strings6[i]);*/
            String[] strings7 = strings[i].split("=");
            for (int j = 0; j < strings7.length; j++) {
                System.out.println(strings7[j]);
            }
            //先按&进行分割，然后再将每组的按=来进行分割，这个时候再来进行打印
        }

        //split是将字符串按指定的内容进行拆分，并且将拆分后的字符串的各个部分分别存进数组中，从而打印
        /*
        String str = "name=zhangsan&age=10";
        String[] strings = str.split("&");
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }
         */
        //比如这个就是按&分割了两部分，那么这个数组的元素就仅仅有两个
        //所以就分成了两个部分
        /**
         * 我的理解：
         * 也就是分割了几个部分，那么新的String数组就是有几个数组元素
         */
    }
}
